<html>
<head><meta charset="utf-8"><title>Approach to rollup PR commit bisections · t-compiler/cargo-bisect-rustc · Zulip Chat Archive</title></head>
<h2>Stream: <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/index.html">t-compiler/cargo-bisect-rustc</a></h2>
<h3>Topic: <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html">Approach to rollup PR commit bisections</a></h3>

<hr>

<base href="https://rust-lang.zulipchat.com">

<head><link href="https://rust-lang.github.io/zulip_archive/style.css" rel="stylesheet"></head>

<a name="188644444"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188644444" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Chris Simpkins <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188644444">(Feb 20 2020 at 14:55)</a>:</h4>
<p>This issue was raised by <span class="user-mention" data-user-id="116083">@pnkfelix</span> during the t-compiler meeting today.  The conversation begins <a href="#narrow/stream/131828-t-compiler/topic/pre-meeting.20triage.202020-02-20.20.2354818/near/188641382" title="#narrow/stream/131828-t-compiler/topic/pre-meeting.20triage.202020-02-20.20.2354818/near/188641382">here</a>.</p>
<p>What is a good approach to bisect within rollup PR commits?  It sounds like we do not have access to within rollup PR cached commit level builds of rustc at the moment to bisect at a more granular level.  The bisect-rustc tool therefore ends in some cases with a report suggesting that a rollup PR commit is the "regressed commit".  This is valid, but not ideal.  It would be helpful to drill down on more granular commit level changes within the rollup PR's during regression diagnostics.  This can be performed manually, but involves a compile of rustc by commit during the bisection.  There is a significant time commitment involved with that approach and this makes it unlikely to be performed outside of high priority circumstances.</p>
<p>cc <span class="user-mention" data-user-id="116122">@simulacrum</span> <span class="user-mention" data-user-id="116266">@Santiago Pastorino</span></p>



<a name="188656508"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188656508" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lqd <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188656508">(Feb 20 2020 at 17:04)</a>:</h4>
<p>I remember talking about this with <span class="user-mention silent" data-user-id="116122">simulacrum</span> and IIRC we mentioned the possibility of maybe doing a try build per rolled-up PR, to have their CI artifacts available for bisection, which would at least help pinpointing the culprit PR. (At the time, this problem was maybe not as prevalent as it can be today)</p>



<a name="188658188"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188658188" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Santiago Pastorino <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188658188">(Feb 20 2020 at 17:24)</a>:</h4>
<p><span class="user-mention silent" data-user-id="262810">Chris Simpkins</span> <a href="#narrow/stream/217417-t-compiler.2Fcargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections/near/188644444" title="#narrow/stream/217417-t-compiler.2Fcargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections/near/188644444">said</a>:</p>
<blockquote>
<p>This issue was raised by <span class="user-mention silent" data-user-id="116083">pnkfelix</span> during the t-compiler meeting today.  The conversation begins <a href="#narrow/stream/131828-t-compiler/topic/pre-meeting.20triage.202020-02-20.20.2354818/near/188641382" title="#narrow/stream/131828-t-compiler/topic/pre-meeting.20triage.202020-02-20.20.2354818/near/188641382">here</a>.</p>
<p>What is a good approach to bisect within rollup PR commits?  It sounds like we do not have access to within rollup PR cached commit level builds of rustc at the moment to bisect at a more granular level.  The bisect-rustc tool therefore ends in some cases with a report suggesting that a rollup PR commit is the "regressed commit".  This is valid, but not ideal.  It would be helpful to drill down on more granular commit level changes within the rollup PR's during regression diagnostics.  This can be performed manually, but involves a compile of rustc by commit during the bisection.  There is a significant time commitment involved with that approach and this makes it unlikely to be performed outside of high priority circumstances.</p>
<p>cc <span class="user-mention silent" data-user-id="116122">simulacrum</span> <span class="user-mention silent" data-user-id="116266">Santiago Pastorino</span></p>
</blockquote>
<p>the only way you have right now is to clone rustc and do the bisect locally in the repo</p>



<a name="188658214"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188658214" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Santiago Pastorino <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188658214">(Feb 20 2020 at 17:24)</a>:</h4>
<p>you would need to build rustc on every step so it will take a lot of time</p>



<a name="188659878"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188659878" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188659878">(Feb 20 2020 at 17:44)</a>:</h4>
<p>yeah. Part of the reason I suggested <a href="#narrow/stream/131828-t-compiler/topic/pre-meeting.20triage.202020-02-20.20.2354818/near/188641794" title="#narrow/stream/131828-t-compiler/topic/pre-meeting.20triage.202020-02-20.20.2354818/near/188641794">plugging in a script</a> is that way you could do things like focus on stage 1 builds, and maybe even leverage incremental compile mode.</p>



<a name="188659958"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188659958" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188659958">(Feb 20 2020 at 17:45)</a>:</h4>
<p>but I suspect it would be better overall to do something like what <span class="user-mention" data-user-id="116113">@lqd</span> suggested</p>



<a name="188664940"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188664940" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Chris Simpkins <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188664940">(Feb 20 2020 at 18:38)</a>:</h4>
<blockquote>
<p>IIRC we mentioned the possibility of maybe doing a try build per rolled-up PR, to have their CI artifacts available for bisection, which would at least help pinpointing the culprit PR</p>
</blockquote>
<p><span class="user-mention" data-user-id="116113">@lqd</span>  <span class="user-mention" data-user-id="116122">@simulacrum</span> A conversation that is worth continuing?  I've gone through several bisect-rustc runs for open ICE issues and in my limited experience, it is common to come across a rollup PR commit as the regression point with this tool.  IIRC, my last stage 1 build took 5+ mins.  In the rollup PR that <span class="user-mention" data-user-id="116083">@pnkfelix</span> mentioned during the meeting, there are 8 + 13 + 13 + 11 + 2 + 1 = 48 commits across the individual PR's in the rollup PR.   To even consider bisection over those commits, we have a  O(n) search across each of the 6 individual PR I think?   If that is a typical rollup PR size, we are talking about a significant amount of time to get to commit level granularity.  And even individual PR level is significant if it involves rustc compiles for each test.</p>



<a name="188665478"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188665478" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lqd <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188665478">(Feb 20 2020 at 18:44)</a>:</h4>
<p>very much worth continuing imo indeed, esp with the new icebreakers cleanup crew, and the continued use of rollups, this will be more and more common I assume</p>



<a name="188665714"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188665714" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188665714">(Feb 20 2020 at 18:47)</a>:</h4>
<p>I did ask during the meeting if one can requrest <code>try</code> bulds on closed PR's. <span class="user-mention" data-user-id="116122">@simulacrum</span> said one cannot currently do this. Should we consider adding that as a feature?</p>



<a name="188665837"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188665837" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188665837">(Feb 20 2020 at 18:49)</a>:</h4>
<p>(An alternative would be to add <code>try</code> build requests  as part of the rollup process, either manually or have a bot do it. But I was figuring that it could make sense until a rollup has been <em>identified</em> before we request its components to be <code>try</code>-built.)</p>



<a name="188665884"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188665884" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Santiago Pastorino <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188665884">(Feb 20 2020 at 18:49)</a>:</h4>
<p><span class="user-mention silent" data-user-id="262810">Chris Simpkins</span> <a href="#narrow/stream/217417-t-compiler.2Fcargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections/near/188664940" title="#narrow/stream/217417-t-compiler.2Fcargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections/near/188664940">said</a>:</p>
<blockquote>
<blockquote>
<p>IIRC we mentioned the possibility of maybe doing a try build per rolled-up PR, to have their CI artifacts available for bisection, which would at least help pinpointing the culprit PR</p>
</blockquote>
<p><span class="user-mention silent" data-user-id="116113">lqd</span>  <span class="user-mention silent" data-user-id="116122">simulacrum</span> A conversation that is worth continuing?  I've gone through several bisect-rustc runs for open ICE issues and in my limited experience, it is common to come across a rollup PR commit as the regression point with this tool.  IIRC, my last stage 1 build took 5+ mins.  In the rollup PR that <span class="user-mention silent" data-user-id="116083">pnkfelix</span> mentioned during the meeting, there are 8 + 13 + 13 + 11 + 2 + 1 = 48 commits across the individual PR's in the rollup PR.   To even consider bisection over those commits, we have a  O(n) search across each of the 6 individual PR I think?   If that is a typical rollup PR size, we are talking about a significant amount of time to get to commit level granularity.  And even individual PR level is significant if it involves rustc compiles for each test.</p>
</blockquote>
<p>I think you don't want commits, you want the PRs included in that rollup, so it will be less shas to cover</p>



<a name="188665906"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188665906" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Santiago Pastorino <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188665906">(Feb 20 2020 at 18:49)</a>:</h4>
<p>rollups do not include more than 10 (?) PRs</p>



<a name="188665975"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188665975" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Santiago Pastorino <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188665975">(Feb 20 2020 at 18:50)</a>:</h4>
<p>it's still a lot given the time it takes to build the compiler but it's not 42 :P</p>



<a name="188666693"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188666693" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Chris Simpkins <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188666693">(Feb 20 2020 at 18:56)</a>:</h4>
<blockquote>
<p>it's still a lot given the time it takes to build the compiler but it's not 42 :P</p>
</blockquote>
<p>I understand.  I guess I am coming at this from the vantage of cleanup crew who try to offset some of the time investment required for diagnostics.  You will need a kind soul to spend 30 - 60 mins building rustc for each issue where a rollup PR is identified by a previous run of cargo-bisect-rustc that took several minutes WITH cached builds. <span aria-label="slight smile" class="emoji emoji-1f642" role="img" title="slight smile">:slight_smile:</span></p>



<a name="188666940"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188666940" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Santiago Pastorino <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188666940">(Feb 20 2020 at 18:59)</a>:</h4>
<p>yep, it's not great :)</p>



<a name="188667098"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188667098" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Chris Simpkins <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188667098">(Feb 20 2020 at 19:01)</a>:</h4>
<blockquote>
<p>can requrest try bulds on closed PR's</p>
</blockquote>
<p><span class="user-mention" data-user-id="116083">@pnkfelix</span> Can you explain what a "try" build is?</p>



<a name="188667138"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188667138" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188667138">(Feb 20 2020 at 19:01)</a>:</h4>
<p><span class="user-mention" data-user-id="262810">@Chris Simpkins</span> sure.</p>



<a name="188667218"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188667218" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188667218">(Feb 20 2020 at 19:02)</a>:</h4>
<p><a href="https://forge.rust-lang.org/infra/docs/rustc-ci.html#try-builds" target="_blank" title="https://forge.rust-lang.org/infra/docs/rustc-ci.html#try-builds">https://forge.rust-lang.org/infra/docs/rustc-ci.html#try-builds</a></p>



<a name="188667229"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188667229" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Chris Simpkins <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188667229">(Feb 20 2020 at 19:02)</a>:</h4>
<p>ty!</p>



<a name="188667239"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188667239" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188667239">(Feb 20 2020 at 19:02)</a>:</h4>
<p>that doc is a little lacking in details though</p>



<a name="188667304"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188667304" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188667304">(Feb 20 2020 at 19:03)</a>:</h4>
<p>basically, its a way to tell the CI, for a given Pull Request, "hey, make a full build off of this."</p>



<a name="188667338"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188667338" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188667338">(Feb 20 2020 at 19:04)</a>:</h4>
<p>we automatically run the CI in a more limited mode on every PR</p>



<a name="188667379"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188667379" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188667379">(Feb 20 2020 at 19:04)</a>:</h4>
<p>but a try build has more stuff in it</p>



<a name="188667447"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188667447" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188667447">(Feb 20 2020 at 19:05)</a>:</h4>
<p>you can request a try build by writing a comment "@bors try"</p>



<a name="188667469"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188667469" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188667469">(Feb 20 2020 at 19:05)</a>:</h4>
<p>see for example <a href="https://forge.rust-lang.org/infra/service-infrastructure.html?highlight=#perf--rust-timer" target="_blank" title="https://forge.rust-lang.org/infra/service-infrastructure.html?highlight=#perf--rust-timer">https://forge.rust-lang.org/infra/service-infrastructure.html?highlight=#perf--rust-timer</a></p>



<a name="188667599"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188667599" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188667599">(Feb 20 2020 at 19:06)</a>:</h4>
<p>which illustrates a way you can get data onto the perf.r-l.o website <em>without</em> committing to merging the PR to master</p>



<a name="188667616"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188667616" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188667616">(Feb 20 2020 at 19:06)</a>:</h4>
<p>by 1. requesting a try build and 2. scheduling that try build to have its own perf run.</p>



<a name="188667673"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188667673" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188667673">(Feb 20 2020 at 19:07)</a>:</h4>
<p>So the reason that <code>try</code> builds are relevant to this conversation is that, if I understand correctly, the CI keeps the artifacts from <code>try</code> builds around the same way it keeps around the artifacts from nightlies and each PR that bors merges.</p>



<a name="188667755"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188667755" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188667755">(Feb 20 2020 at 19:08)</a>:</h4>
<p>and therefore, we could leverage <code>try</code> when doing rollups to request that the CI produce the necessary builds that <code>cargo-bisect-rustc</code> would need to automatically download and run the builds.</p>



<a name="188671272"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188671272" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Chris Simpkins <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188671272">(Feb 20 2020 at 19:49)</a>:</h4>
<p>Got it.   Now the comment that you cannot perform try builds on closed PR makes sense to me.  It would be nice to avoid the need to execute try builds + caching on every roll up PR.  Thanks for the detailed explanation</p>



<a name="188676544"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188676544" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188676544">(Feb 20 2020 at 20:53)</a>:</h4>
<p>note that a try build is <em>way</em> less than a full CI run</p>



<a name="188676621"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188676621" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188676621">(Feb 20 2020 at 20:54)</a>:</h4>
<p>a full CI run is like 60 builders at around 3 hours each, whereas try is around the same time but just 2 builders.</p>



<a name="188676661"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188676661" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188676661">(Feb 20 2020 at 20:54)</a>:</h4>
<p>I think try on closed PRs is a bit hard as try by default rebases the PR onto master, so it's a bit unclear that you'd get the artifacts you want from that :)</p>



<a name="188676709"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188676709" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188676709">(Feb 20 2020 at 20:55)</a>:</h4>
<p>also, bors today breaks on try after r+ so we added error handling and just flat out forbid it</p>



<a name="188676808"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188676808" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188676808">(Feb 20 2020 at 20:56)</a>:</h4>
<p>oh wow it breaks after r+?</p>



<a name="188676820"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188676820" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188676820">(Feb 20 2020 at 20:56)</a>:</h4>
<p>what if there's a subsequent r- and followon commits?</p>



<a name="188676873"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188676873" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188676873">(Feb 20 2020 at 20:57)</a>:</h4>
<p>it's fine so long as you don't have the PR approved and try to try it</p>



<a name="188676890"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188676890" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188676890">(Feb 20 2020 at 20:57)</a>:</h4>
<p>also: just to correct my own thinking: How does the try build compare to the automatic build the CI does? (<del>Travis</del> <del>Azure</del> Github Actions) ?</p>



<a name="188676895"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188676895" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188676895">(Feb 20 2020 at 20:57)</a>:</h4>
<p>Azure for now :)</p>



<a name="188676902"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188676902" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188676902">(Feb 20 2020 at 20:57)</a>:</h4>
<blockquote>
<p>a full CI run is like 60 builders at around 3 hours each, whereas try is around the same time but just 2 builders.</p>
</blockquote>



<a name="188676918"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188676918" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188676918">(Feb 20 2020 at 20:57)</a>:</h4>
<p>I'm not speaking clearly</p>



<a name="188676965"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188676965" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188676965">(Feb 20 2020 at 20:58)</a>:</h4>
<p>I meant in comparison to the one that automatically happens on every PR that is opened</p>



<a name="188676975"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188676975" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188676975">(Feb 20 2020 at 20:58)</a>:</h4>
<p>is the only difference that the <code>try</code> build does a rebase onto master?</p>



<a name="188677016"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188677016" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188677016">(Feb 20 2020 at 20:58)</a>:</h4>
<p>I had thought that the <code>try</code> build still includes "more" stuff than the automagic build</p>



<a name="188677041"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188677041" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188677041">(Feb 20 2020 at 20:59)</a>:</h4>
<p>ah, so the automatic one is basically a "test" build on some loosely "random" commit (IIRC, we use the default logic, so this is a merge commit with master at the time of the last push to the branch), whereas a try build is rebase onto master + dist build</p>



<a name="188677078"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188677078" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188677078">(Feb 20 2020 at 20:59)</a>:</h4>
<p>from an infra perspective, the difference is that a try build has credentials to upload to S3, PR builds cannot for security reasons.</p>



<a name="188677110"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188677110" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188677110">(Feb 20 2020 at 20:59)</a>:</h4>
<p>ah. and also a "test" build has less stuff in it than a "dist" build, right?</p>



<a name="188677209"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188677209" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188677209">(Feb 20 2020 at 21:00)</a>:</h4>
<p>like you're referring to the difference between <code>x.py test</code> vs <code>x.py dist</code>, right?</p>



<a name="188677230"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188677230" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188677230">(Feb 20 2020 at 21:00)</a>:</h4>
<p>basically, yes</p>



<a name="188677262"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188677262" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188677262">(Feb 20 2020 at 21:01)</a>:</h4>
<p>I <em>think</em> we might not build tools in these dist builders today? not sure</p>



<a name="188677303"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188677303" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188677303">(Feb 20 2020 at 21:01)</a>:</h4>
<p>hm, no I think we do</p>



<a name="188677322"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188677322" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188677322">(Feb 20 2020 at 21:01)</a>:</h4>
<p>but yeah PR CI is more limited</p>



<a name="188678484"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188678484" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188678484">(Feb 20 2020 at 21:12)</a>:</h4>
<p>hmm. I guess one problem with the idea of using the <code>try</code> builds to generate the desired artifacts is that the <code>try</code> builds only make things for, what, just Linux?</p>



<a name="188678539"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188678539" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188678539">(Feb 20 2020 at 21:12)</a>:</h4>
<p>(at least, that's a problem for someone trying to use <code>cargo-bisect-rustc</code> on a Mac.)</p>



<a name="188678542"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188678542" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188678542">(Feb 20 2020 at 21:12)</a>:</h4>
<p>just linux yeah</p>



<a name="188678556"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188678556" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188678556">(Feb 20 2020 at 21:13)</a>:</h4>
<p>in theory docker or something</p>



<a name="188678591"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188678591" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188678591">(Feb 20 2020 at 21:13)</a>:</h4>
<p>but I think for intra-rollup bisections requiring a linux computer is not too bad</p>



<a name="188678599"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188678599" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188678599">(Feb 20 2020 at 21:13)</a>:</h4>
<p>maybe I'm wrong :)</p>



<a name="188678676"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188678676" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188678676">(Feb 20 2020 at 21:14)</a>:</h4>
<p>I don't mind it if it means we can get something rolling quickly.</p>



<a name="188678746"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188678746" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188678746">(Feb 20 2020 at 21:15)</a>:</h4>
<p>I personally think that we might have enough capacity to just pre-run try as soon as something is r+ed</p>



<a name="188678774"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188678774" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188678774">(Feb 20 2020 at 21:15)</a>:</h4>
<p>we basically need to fix the bug I think</p>



<a name="188678782"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188678782" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188678782">(Feb 20 2020 at 21:16)</a>:</h4>
<p>(bors bug, that is)</p>



<a name="188678843"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188678843" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188678843">(Feb 20 2020 at 21:16)</a>:</h4>
<p>like run <code>try</code> on <em>every</em> r+  of a PR ?</p>



<a name="188678874"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188678874" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188678874">(Feb 20 2020 at 21:16)</a>:</h4>
<p>hm, well, maybe not every</p>



<a name="188678881"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188678881" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188678881">(Feb 20 2020 at 21:16)</a>:</h4>
<p>I guess ideally we'd restrict to just rollups</p>



<a name="188678890"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188678890" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188678890">(Feb 20 2020 at 21:17)</a>:</h4>
<p>but we only know that after the fact...</p>



<a name="188678919"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188678919" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188678919">(Feb 20 2020 at 21:17)</a>:</h4>
<p>maybe every PR not marked with rollup=never</p>



<a name="188678988"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188678988" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188678988">(Feb 20 2020 at 21:18)</a>:</h4>
<p>heh. that would make for some <em>great</em> workflow docs. "Yeah we always include rollup=never because otherwise our CI $$$ is too high.")</p>



<a name="188679023"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188679023" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188679023">(Feb 20 2020 at 21:18)</a>:</h4>
<p>One alternative -- maybe worth considering -- is that it's actually likely fairly fast to build PRs included in a rollup on decent hardware</p>



<a name="188679040"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188679040" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188679040">(Feb 20 2020 at 21:18)</a>:</h4>
<p>or, rather, I take that back</p>



<a name="188679045"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188679045" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188679045">(Feb 20 2020 at 21:18)</a>:</h4>
<p>you mean locally?</p>



<a name="188679050"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188679050" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188679050">(Feb 20 2020 at 21:19)</a>:</h4>
<p>yeah</p>



<a name="188679067"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188679067" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188679067">(Feb 20 2020 at 21:19)</a>:</h4>
<p>like checkout at the start commit, and leverage incremental compiles to get each one?</p>



<a name="188679071"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188679071" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188679071">(Feb 20 2020 at 21:19)</a>:</h4>
<p>basically, yeah</p>



<a name="188679082"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188679082" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188679082">(Feb 20 2020 at 21:19)</a>:</h4>
<p>that might be pretty slow still, not sure</p>



<a name="188679101"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188679101" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188679101">(Feb 20 2020 at 21:19)</a>:</h4>
<p>I guess it depends on the rollup</p>



<a name="188679108"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188679108" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188679108">(Feb 20 2020 at 21:19)</a>:</h4>
<p>that then puts us back at the problem we didn't want to try to solve: having cargo-bisect-rustc do local builds</p>



<a name="188679118"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188679118" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188679118">(Feb 20 2020 at 21:19)</a>:</h4>
<p>true</p>



<a name="188679304"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188679304" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188679304">(Feb 20 2020 at 21:20)</a>:</h4>
<p>I think if we had docs for how to generate a PR post-facto on which we could run try builds that might be good too</p>



<a name="188679310"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188679310" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188679310">(Feb 20 2020 at 21:20)</a>:</h4>
<p>by the way, who has merge permissions on cargo-bisect-rustc ?</p>



<a name="188679335"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188679335" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188679335">(Feb 20 2020 at 21:20)</a>:</h4>
<p>uh, I do, not sure if <span class="user-mention" data-user-id="116266">@Santiago Pastorino</span> does, probably <em>should</em></p>



<a name="188679337"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188679337" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188679337">(Feb 20 2020 at 21:20)</a>:</h4>
<p>really anyone can merge :)</p>



<a name="188679338"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188679338" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188679338">(Feb 20 2020 at 21:21)</a>:</h4>
<p>maybe I can figure this out</p>



<a name="188679359"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188679359" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188679359">(Feb 20 2020 at 21:21)</a>:</h4>
<p>anyone ? I didn't see a merge button when  I looked at a PR recently</p>



<a name="188679374"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188679374" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188679374">(Feb 20 2020 at 21:21)</a>:</h4>
<p>well, I meant in a hypothetical sense</p>



<a name="188679380"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188679380" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188679380">(Feb 20 2020 at 21:21)</a>:</h4>
<p>like, t-compiler knows enough</p>



<a name="188679391"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188679391" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188679391">(Feb 20 2020 at 21:21)</a>:</h4>
<p>oh oh I see</p>



<a name="188679499"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188679499" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188679499">(Feb 20 2020 at 21:22)</a>:</h4>
<p>added t-compiler I think</p>



<a name="188679523"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/188679523" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#188679523">(Feb 20 2020 at 21:23)</a>:</h4>
<p>okay now I see the button, thanks</p>



<a name="189041147"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/189041147" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Chris Simpkins <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#189041147">(Feb 25 2020 at 17:31)</a>:</h4>
<blockquote>
<p>I think if we had docs for how to generate a PR post-facto on which we could run try builds that might be good too</p>
</blockquote>
<p><span class="user-mention" data-user-id="116122">@simulacrum</span> Would the workflow then be that a new PR is pushed when a roll up PR commit is identified as a regression, then once the try build is complete the bisect process can continue on the commits in that PR? What docs are needed?</p>



<a name="189041307"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/189041307" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#189041307">(Feb 25 2020 at 17:33)</a>:</h4>
<p>Well, yes, but making that PR is relatively hard today, in that you need to move master back (a bunch of revert commits) and then gradually re-apply the rollup, running try each time. Note that the matter may not even work on each commit!</p>



<a name="189044677"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/189044677" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#189044677">(Feb 25 2020 at 18:08)</a>:</h4>
<p>what about doing a try build on the original PR's linked from the rollup? Those should all build, right?</p>



<a name="189044695"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/189044695" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#189044695">(Feb 25 2020 at 18:09)</a>:</h4>
<p>its not <em>quite</em> the same, since bugs can get injected in the process of merging, I admit ...</p>



<a name="189044712"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/189044712" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#189044712">(Feb 25 2020 at 18:09)</a>:</h4>
<p>but it would probably be effective in diagnosing the injection in 99% of the cases?</p>



<a name="189045155"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/189045155" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Santiago Pastorino <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#189045155">(Feb 25 2020 at 18:13)</a>:</h4>
<p>my understanding is that means that the PR would be merged on top of a completely different master to the one it was merged and by definition it would never apply cleanly</p>



<a name="189045220"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/189045220" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Santiago Pastorino <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#189045220">(Feb 25 2020 at 18:14)</a>:</h4>
<p>so you would need the master you had at the time the PR was merged</p>



<a name="189045244"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/189045244" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Santiago Pastorino <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#189045244">(Feb 25 2020 at 18:14)</a>:</h4>
<p>I guess this is why <span class="user-mention" data-user-id="116122">@simulacrum</span> is saying that you need to move master back</p>



<a name="189045266"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/189045266" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#189045266">(Feb 25 2020 at 18:14)</a>:</h4>
<p>oh right, I forgot again that try merges to current master (and misinterpreted <span class="user-mention" data-user-id="116122">@simulacrum</span> 's comment)</p>



<a name="189045333"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/189045333" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#189045333">(Feb 25 2020 at 18:15)</a>:</h4>
<p>but then ... is there a way we could ask <code>try</code> to do a build based on the master that the PR was connected to? I mean, this sounds straight-forward in principle...</p>



<a name="189045382"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/189045382" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Santiago Pastorino <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#189045382">(Feb 25 2020 at 18:16)</a>:</h4>
<p>yeah, one could fork a new branch from the commit that was on top at the time and merge there</p>



<a name="189045426"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/189045426" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Santiago Pastorino <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#189045426">(Feb 25 2020 at 18:16)</a>:</h4>
<p>unsure how the process work and if that is complicated for some reason</p>



<a name="189045516"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/189045516" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Santiago Pastorino <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#189045516">(Feb 25 2020 at 18:17)</a>:</h4>
<p>it won't be the current try</p>



<a name="189045530"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/189045530" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Santiago Pastorino <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#189045530">(Feb 25 2020 at 18:17)</a>:</h4>
<p>let's call it try-back</p>



<a name="189045607"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/189045607" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Santiago Pastorino <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#189045607">(Feb 25 2020 at 18:18)</a>:</h4>
<p>but would be nice if one could request that once cargo-bisect-rustc finds a regression in a rollup</p>



<a name="189045667"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach%20to%20rollup%20PR%20commit%20bisections/near/189045667" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Santiago Pastorino <a href="https://rust-lang.github.io/zulip_archive/stream/217417-t-compiler/cargo-bisect-rustc/topic/Approach.20to.20rollup.20PR.20commit.20bisections.html#189045667">(Feb 25 2020 at 18:19)</a>:</h4>
<p>so you do a "try-back" #PR1 #PR2 #PR3 and you get try-back-PR1, try-back-PR2, branches and the artifacts</p>



<hr><p>Last updated: Aug 07 2021 at 22:04 UTC</p>
</html>